home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / PROGENV / SrcBrowser.C < prev    next >
C/C++ Source or Header  |  1992-07-09  |  14KB  |  597 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "CodeTextView.h"       // cpp: max nesting level
  6. #include "SrcBrowser.h"
  7.  
  8. #include "ET++.h"
  9.  
  10. #include "StyledText.h"
  11. #include "TextFormatter.h"
  12. #include "OrdColl.h"
  13. #include "WindowSystem.h"
  14. #include "PathLookup.h"
  15. #include "GotoDialog.h"
  16. #include "ClassManager.h"
  17. #include "MenuBar.h"
  18. #include "Env.h"
  19. #include "Data.h"
  20. #include "FindChange_e.h"
  21. #include "Math.h"
  22. #include "Fields.h"
  23.  
  24. #include "EtProgEnv.h"
  25. #include "ClassList.h"
  26. #include "MethodB.h"
  27. #include "EtPeCmdNo.h"
  28. #include "EtPeManager.h"
  29. #include "EtPeTool.h"
  30.  
  31. //---- SourceBrowser -----------------------------------------------------------
  32.  
  33. NewMetaImpl(PeSourceBrowser, Document, (TP(textview), TP(listview), TP(text), TP(ccl), TP(log),
  34.                                 TB(isCCode)));
  35. int PeSourceBrowser::srcCount;
  36. PeSourceBrowser *PeSourceBrowser::browser;
  37.  
  38. PeSourceBrowser::PeSourceBrowser(Manager *m) : Document(cDocTypeAscii)
  39. {
  40.     m->AddManager(this);
  41.     Font *fd= gFixedFont;
  42.     if (Env::GetValue("CodeText.UseStyles", TRUE))
  43.     text= new StyledText(256, fd);
  44.     else
  45.     text= new GapText(256, fd);
  46.     text->SetDefTab(fd->Width(' ') * Env::GetValue("CodeText.TabPos", 8));
  47.  
  48.     ccl= 0;
  49.     definition= FALSE;
  50.     log= new OrdCollection;
  51.     isCCode= FALSE;
  52.     base= (srcCount++ == 0);
  53. }
  54.  
  55. PeSourceBrowser::~PeSourceBrowser()
  56. {
  57.     SafeDelete(textview);
  58.     SafeDelete(listview);
  59.     SafeDelete(text);
  60.     SafeDelete(log);
  61.     SafeDelete(methods);
  62.     SafeDelete(implementors);
  63. }
  64.  
  65. VObject *PeSourceBrowser::DoMakeContent()
  66. {   
  67.     textview= new PeSrcBrowserTextView(this, Rectangle(Point(2000,cFit)), text);
  68.     listview= new PeClassListView(this);
  69.     methods= new PeMethodBrowser(this);
  70.     implementors= new PeImplementors(this);
  71.     SetFirstHandler(textview);
  72.     classScroller= new Scroller(listview, Point(-1, 100));
  73.     classScroller->SetFlag(eVObjHFixed);
  74.  
  75.     methodScroller= new Scroller(methods);
  76.  
  77.     implTitle= new TextField(cIdNone, 20, gFixedFont->WithFace(eFaceItalic));
  78.     implTitle->SetEditable(FALSE);
  79.     
  80.     return
  81.     new VExpander(gPoint2, 
  82.         new HBox(gPoint2, (VObjAlign)(eVObjHExpand|eVObjVEqual),
  83.         classScroller,
  84.         methodScroller,
  85.         //new VExpander(gPoint2,
  86.         new VBox(gPoint2, (VObjAlign)(eVObjVExpand|eVObjHExpand),
  87.             implTitle,
  88.             new Scroller(implementors),
  89.             0
  90.         ),
  91.         0
  92.         ),
  93.         new Scroller(textview, Point(550, 300)),
  94.         0
  95.     );
  96. }
  97.  
  98. void PeSourceBrowser::InputKbd(Token &t)
  99. {
  100.     if (EtPeTool::WantGrabKeyToken(t, classScroller))
  101.     classScroller->Input(t.Pos, t, GetWindow());
  102.     else if (EtPeTool::WantGrabKeyToken(t, methodScroller))
  103.     methodScroller->Input(t.Pos, t, GetWindow());
  104.     else
  105.     Document::InputKbd(t);
  106. }
  107.  
  108. bool PeSourceBrowser::LoadData(Data *d, bool unique)
  109. {
  110.     bool ok= Document::LoadData(d, unique);
  111.     if (ok) {
  112.     ccl= 0;
  113.     listview->SelectClass(ccl);
  114.     methods->ShowMethodsOf(ccl);
  115.     }
  116.     return ok;
  117. }
  118.  
  119. void PeSourceBrowser::SetWindowTitle(char *name)
  120. {
  121.     if (base)
  122.     GetWindow()->SetTitle(form("*** %s ***", name));
  123.     else
  124.     Document::SetWindowTitle(name);
  125. }
  126.  
  127. bool PeSourceBrowser::CanImport(Data *data)
  128. {
  129.     if (data)
  130.     return data->CanConvert(Meta(Text));
  131.     return TRUE;
  132. }
  133.  
  134. Command *PeSourceBrowser::DoImport(Data *data)
  135. {
  136.     Text *t;
  137.     if (t= (Text*) data->AsObject(Meta(Text))) {
  138.     Command *cmd= textview->InsertText(t);
  139.     SafeDelete(t);
  140.     return cmd;
  141.     }
  142.     return gNoChanges;
  143. }
  144.  
  145. bool PeSourceBrowser::DoWrite(OStream &s, Data*)
  146. {
  147.     // ??? terminate last line with a '\n' ???
  148.     if ((*text)[text->Size()-1] != '\n')
  149.     text->Append('\n');
  150.     text->PrintOnAsPureText(s);
  151.     return TRUE;
  152. }
  153.  
  154. bool PeSourceBrowser::DoReadData(Data *data)
  155. {
  156.     IStream s(data->GetStreamBuf());
  157.     text->ReadFromAsPureText(s, data->SizeHint());
  158.     if (isCCode= data->IsCCode())
  159.     textview->FormatCode();
  160.     else
  161.     textview->SetDefaultStyle();
  162.     textview->SetText(text);
  163.     return TRUE;
  164. }
  165.  
  166. void PeSourceBrowser::RevealAndSelectLine(int l)
  167. {
  168.     LineMark *lm= textview->MarkAtLine(Math::Range(0, textview->Lines()-1, l-1));
  169.     textview->SetSelection(lm->Pos(),lm->End());
  170.     Rectangle r= textview->SelectionRect();
  171.     textview->Scroll(cPartScrollAbs, Point(0,r.origin.y)+Point(0,2));
  172. }
  173.  
  174. void PeSourceBrowser::Log(Class *cl)
  175. {
  176.     if (cl != ccl)
  177.     log->Add(cl);
  178. }
  179.  
  180. void PeSourceBrowser::Control(int id, int what, void *val)
  181. {
  182.     PeMethodReference *mr= (PeMethodReference *)val;
  183.     
  184.     switch (what) {
  185.     case cPeCLChangedClass:
  186.     SetClass((Class*)val, definition);
  187.     break;
  188.     
  189.     case cPeChangedMethod:
  190.     RevealMethod(mr);
  191.     break;
  192.     
  193.     case cPeImplementors:
  194.     { 
  195.         GrShowWaitCursor wc;
  196.         implTitle->SetFString(TRUE, "implementors of: %s", mr->Str());
  197.         implementors->ShowImplementorsOf(mr, FALSE);
  198.     }
  199.     break;
  200.     
  201.     case cPeInherited:
  202.     implTitle->SetFString(TRUE, "inherited: %s", mr->Str());
  203.     implementors->ShowInherited(mr);
  204.     break;
  205.     
  206.     case cPeOverrides:
  207.     implTitle->SetFString(TRUE, "overrides of: %s", mr->Str());
  208.     implementors->ShowImplementorsOf(mr, TRUE);
  209.     break;
  210.     
  211.     default:
  212.     Document::Control(id, what, val);
  213.     }
  214. }
  215.  
  216. void PeSourceBrowser::SetClass(Class *cl, bool what, bool reveal)
  217. {
  218.     Log(cl);
  219.     DoSetClass(cl, what, TRUE, reveal);
  220. }
  221.  
  222. void PeSourceBrowser::RevealMethod(PeMethodReference *mr)
  223. {
  224.     SetClass(mr->GetClass(), FALSE, FALSE);
  225.     textview->ShowMethod(mr);
  226.     methods->SelectMethod(mr);
  227. }
  228.  
  229. void PeSourceBrowser::DoSetClass(Class *cl, bool decl, bool unique, bool reveal)
  230. {
  231.     char fname[1000];
  232.     bool sameClass= (cl == ccl && decl == definition);
  233.     bool sameFile= FALSE;
  234.  
  235.     if (!sameClass) {
  236.     if (!gEtPeManager->FileOfClass(cl, fname, decl)) {
  237.         ShowAlert(eAlertNote, "Can't find file @B%s@P in Env::SrcPath\n",
  238.                                 BaseName(fname));
  239.         return;
  240.     }
  241.  
  242.     FileData *fd= new FileData(fname);
  243.     if (fd->UniqueId() != UniqueId()) {
  244.         if (! LoadData(fd, unique)) {
  245.         listview->SelectClass(ccl);
  246.         return;
  247.         }
  248.     } else {
  249.         sameFile= TRUE;
  250.         delete fd;
  251.     }
  252.     definition= decl;
  253.     ccl= cl;
  254.     listview->SelectClass(ccl);
  255.     Send(cPeSourceBrowser, cPeCLSelectClass, ccl);
  256.     methods->ShowMethodsOf(cl);
  257.     SafeDelete(fd);     
  258.     }
  259.     if (reveal)
  260.     SelectSourceLine(sameFile);   
  261. }
  262.  
  263. void PeSourceBrowser::SelectSourceLine(bool)
  264. {
  265.     int line;
  266.     if (definition)
  267.     line= ccl->GetDeclFileLine();
  268.     else 
  269.     line= ccl->GetImplFileLine();
  270.  
  271.     RevealAndSelectLine(line);
  272. }
  273.  
  274. void PeSourceBrowser::SetMode(bool what)
  275. {
  276.     SetClass(ccl, what);
  277. }
  278.     
  279. void PeSourceBrowser::Spawn()
  280. {
  281.     SavedChanges();
  282.     Spawn(gEtPeManager, ccl, definition);
  283. }
  284.  
  285. void PeSourceBrowser::EditSelectedClass()
  286. {
  287.     char *classname= FirstWordOfSelection();
  288.     Class *clp= gClassManager->Find(classname);
  289.     if (clp)
  290.     SetClass(clp,definition);
  291.     else
  292.     ShowAlert(eAlertNote, "No Metaclass found for \"%s\" ?", classname);
  293. }
  294.  
  295. void PeSourceBrowser::ShowImplementors()
  296. {
  297.     PeMethodReference mr(0, 0, FirstWordOfSelection(), FALSE);
  298.     implementors->ShowImplementorsOf(&mr, FALSE);
  299. }
  300.  
  301. void PeSourceBrowser::InspectSomeInstance()
  302. { 
  303.     Object *op= ccl->SomeMember();
  304.     if (!op)
  305.     op= ccl->SomeInstance();
  306.     if (op)
  307.     op->Inspect();
  308.     else
  309.     ShowAlert(eAlertNote, "No instances found");
  310. }
  311.  
  312. MenuBar *PeSourceBrowser::DoMakeMenuBar()
  313. {
  314.     MenuBar *mb= Document::DoMakeMenuBar();
  315.     
  316.     //---- file menu
  317.     Menu *m= new Menu("Classes");
  318.     m->AppendItems( "Other",                  cEDITOTHER,
  319.             "Superclass",             cEDITSUPER,
  320.             "Spawn",                  cSPAWN,
  321.             "-",
  322.             "Inspect Some Instance",  cINSPECTSOME,
  323.             "-",
  324.             "Show in Hierarchy",      cSHOWHIERARCHY,
  325.             "-",
  326.             "Previous Class",         cGOBACK,
  327.             "Empty Classes",          cEMPTYCLASSES,
  328.             0);
  329.     mb->AddMenu(m);
  330.  
  331.     m= new Menu("Methods");
  332.     m->AppendItems( "Implementors",     cIMPLEMENTORS,
  333.             "Overrides",        cOVERRIDES,
  334.             "Inherited",        cINHERITED,
  335.             "References",       cMETHREFERENCES,
  336.             "-",
  337.             "Filter...",        cFILTER,
  338.             "Remove Filter",    cREMFILTER,
  339.             0);
  340.     mb->AddMenu(m);
  341.     
  342.     m= new Menu("Utilities");
  343.     m->AppendItems( "Edit Selected Class",    cEDITSELECTED,
  344.             "Go to Line...",          cGOTOLINE,
  345.             "Reformat",               cREFORMATCODE,
  346.             0);
  347.     mb->AddMenu(m);
  348.  
  349.     FindChange::InstallChange(mb, textview);
  350.     
  351.     return mb;
  352. }
  353.  
  354. void PeSourceBrowser::DoSetupMenu(Menu *menu)
  355. {
  356.     menu->ToggleItem(cEDITOTHER, definition, "Implementation", "Definition");
  357.  
  358.     if (ccl)
  359.     menu->EnableItems(cEDITOTHER, 
  360.               cSPAWN, 
  361.               cSHOWHIERARCHY,
  362.               cSHOWINHPATH, 
  363.               cINSPECTSOME,
  364.               cUTILMENU,
  365.               0);
  366.               
  367.     if (isCCode && text->IsKindOf(StyledText))
  368.     menu->EnableItem(cREFORMATCODE);
  369.  
  370.     menu->EnableItems(cGOTOLINE, cEMPTYCLASSES, 0);
  371.     
  372.     if (ccl && ccl->Super())
  373.     menu->EnableItem(cEDITSUPER);
  374.     if (log->Size() > 1)
  375.     menu->EnableItem(cGOBACK);
  376.      
  377.     menu->ToggleItem(cEMPTYCLASSES, listview->HideEmptyClasses(), 
  378.              "Show All Classes",
  379.              "Hide Classes with no Instances");
  380.     
  381.     menu->ReplaceItem(cEDITSELECTED, "Selected Class/Method");
  382.     if (!textview->Caret()) {
  383.     char *q= FirstWordOfSelection();
  384.     if (strlen(q)) {
  385.         menu->ReplaceItem(cEDITSELECTED, form("Show \"%s\"", q));
  386.         menu->EnableItem(cEDITSELECTED);
  387.     }
  388.     }
  389.     
  390.     if (methods->GetSelectedMethod() != 0) {
  391.     menu->EnableItem(cIMPLEMENTORS);
  392.     menu->EnableItem(cOVERRIDES);
  393.     menu->EnableItem(cINHERITED);
  394.     }
  395.     menu->EnableItems(cFILTER, cREMFILTER, 0);
  396.     
  397.     Document::DoSetupMenu(menu);
  398. }
  399.  
  400. char *PeSourceBrowser::FirstWordOfSelection()
  401. {
  402.     static byte buf[60];
  403.     textview->SelectionAsString(buf, sizeof buf);
  404.     for (byte *q= buf; *q; q++)
  405.     if (Isinword(*q)) break;
  406.     for (byte *p= q; *p; p++)
  407.     if (!Isinword(*p)) break;
  408.     *p= '\0';
  409.     return (char*) q;
  410. }
  411.  
  412. Command *PeSourceBrowser::DoMenuCommand(int cmd)
  413. {
  414.     char *q;
  415.     PeMethodItem *mi= methods->GetSelectedMethod();
  416.     
  417.     switch (cmd) {
  418.  
  419.     case cFIND:
  420.     FindChange::ShowChangeDialog(textview);
  421.     break;
  422.     
  423.     case cEDITOTHER:
  424.     SetMode(!definition);
  425.     break;
  426.     
  427.     case cEDITSUPER:
  428.     SetClass(ccl->Super(), definition);
  429.     break;
  430.     
  431.     case cINSPECTSOME:
  432.     InspectSomeInstance();
  433.     break;
  434.     
  435.     case cEDITSELECTED:
  436.     { 
  437.     GrShowWaitCursor wc;
  438.     q= FirstWordOfSelection();
  439.     if (gClassManager->Find(q))
  440.         EditSelectedClass();
  441.     else
  442.         ShowImplementors();
  443.     }
  444.     break;
  445.     
  446.     case cEMPTYCLASSES:
  447.     listview->ToggleHideEmpty();
  448.     listview->SelectClass(ccl);
  449.     break;
  450.     
  451.     case cGOBACK:
  452.     log->RemoveAt(log->Size()-1);
  453.     DoSetClass((Class*)log->Last(), definition, TRUE, TRUE);
  454.     break;
  455.  
  456.     case cSPAWN:
  457.     Spawn();
  458.     break;
  459.     
  460.     case cSHOWHIERARCHY:
  461.     gEtPeManager->Control(cPeSourceBrowser, cPeShowHierarchy, ccl);
  462.     break;
  463.     
  464.     case cGOTOLINE:
  465.     GotoLine(textview);
  466.     break;
  467.     
  468.     case cREFORMATCODE:
  469.     textview->FormatCode();
  470.     textview->RepairAll();
  471.     return gNoChanges;
  472.  
  473.     case cIMPLEMENTORS:
  474.     Control(cPeSourceBrowser, cPeImplementors, mi->mrp);
  475.     break;
  476.     
  477.     case cOVERRIDES:
  478.     Control(cPeSourceBrowser, cPeOverrides, mi->mrp);
  479.     break;
  480.     
  481.     case cINHERITED:
  482.     Control(cPeSourceBrowser, cPeInherited, mi->mrp);
  483.     break;
  484.     
  485.     case cFILTER:
  486.     methods->Filter();
  487.     break;    
  488.  
  489.     case cREMFILTER:
  490.     methods->RemoveFilter();
  491.     break;    
  492.  
  493.     default:
  494.     break;
  495.     }
  496.     return Document::DoMenuCommand(cmd);
  497. }
  498.  
  499. void PeSourceBrowser::CollectParts(Collection *col)
  500. {
  501.     EvtHandler::CollectParts(col);
  502. }
  503.  
  504. void PeSourceBrowser::Spawn(Manager *m, Class *cp, bool decl, int at)
  505. {
  506.     PeSourceBrowser *sb= new PeSourceBrowser(m);
  507.     sb->SetOnDismiss(eMgrClose);
  508.     sb->Show();
  509.     sb->DoSetClass(cp, decl, FALSE, at == -1);
  510.     if (at != -1) 
  511.     sb->RevealAndSelectLine(at);
  512. }
  513.  
  514. void PeSourceBrowser::ShowClass(Manager *m, Class *cp, bool decl, int at)
  515. {
  516.     if (browser == 0)
  517.     browser= new PeSourceBrowser(m);
  518.     browser->Show();
  519.     browser->SetClass(cp, decl, at == -1);
  520.     if (at != -1) 
  521.     browser->RevealAndSelectLine(at);
  522. }
  523.  
  524. //---- PeSrcBrowserTextView ------------------------------------------------------
  525.  
  526. NewMetaImpl0(PeSrcBrowserTextView, CodeTextView);
  527.  
  528. PeSrcBrowserTextView::PeSrcBrowserTextView(EvtHandler *eh, Rectangle r, Text *t)
  529.                            : CodeTextView(eh, r, t)
  530. {
  531. }
  532.  
  533. PrettyPrinter *PeSrcBrowserTextView::MakePrettyPrinter(Text *t, 
  534.             CharStyle *cs, CharStyle *fs, CharStyle *cds, CharStyle *ps)
  535. {
  536.     return new PeSrcBrowserPPrinter(this, t, cs, fs, cds, ps);
  537. }
  538.  
  539. void PeSrcBrowserTextView::ShowMethod(PeMethodReference *mr)
  540. {
  541.     MarkList *mlp= GetMarkList();
  542.     Iter next(mlp->MakeIterator());
  543.     PeMethodMark *mp;
  544.     bool found= FALSE;
  545.     
  546.     while (mp= (PeMethodMark*)next()) {
  547.     if (strcmp(mp->className, mr->GetClass()->Name()) == 0 &&
  548.                  strcmp(mp->method, (char*)mr->Str()) == 0) {
  549.         SetSelection(mp->Pos(),mp->End());
  550.         found= TRUE;
  551.         break;
  552.     }
  553.     }
  554.     // no mark found, use position information stored in mr
  555.     if (!found) {
  556.     LineMark *lm= MarkAtLine(Math::Range(0, Lines()-1, mr->Line()-1));
  557.     SetSelection(lm->Pos(),lm->End());
  558.     }
  559.     Rectangle r= SelectionRect();
  560.     Scroll(cPartScrollAbs, Point(0,r.origin.y)+Point(0,-4));
  561. }
  562.  
  563. //---- PeSrcBrowserPPrinter ------------------------------------------------------
  564.  
  565. PeSrcBrowserPPrinter::PeSrcBrowserPPrinter(PeSrcBrowserTextView *tv, Text *t, 
  566.             CharStyle *cs, CharStyle *fs, CharStyle *cds, CharStyle *ps)
  567.                          : PrettyPrinter(t, cs, fs, cds, ps)
  568. {
  569.     tvp= tv;
  570.     tv->GetMarkList()->FreeAll();
  571. }
  572.  
  573. void PeSrcBrowserPPrinter::Function(int line, int start, int end, char *name, char *classname)
  574. {
  575.     PrettyPrinter::Function(line, start, end, name, classname);
  576.  
  577.     if (classname) 
  578.     tvp->AddMark(new PeMethodMark(classname, name, start, end-start));
  579. }
  580.  
  581. //---- PeMethodMark --------------------------------------------------------------
  582.  
  583. NewMetaImpl(PeMethodMark, Mark, (TP(className), TP(method)));
  584.     
  585. PeMethodMark::PeMethodMark(char *c, char *m, int p, int l) : Mark(p, l)
  586. {
  587.     className= strsave(c);
  588.     method= strsave(m);
  589. }
  590.  
  591. PeMethodMark::~PeMethodMark()
  592. {
  593.     SafeDelete(className);
  594.     SafeDelete(method);
  595. }
  596.  
  597.